{
 "cells": [
  {
   "source": [
    "## 读取数据\n",
    "- `series_to_supervised`将时间序列转化成监督性学习"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas import DataFrame\n",
    "from pandas import concat\n",
    "import math\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import cv2 as cv\n",
    "import csv\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):\n",
    "    \"\"\"\n",
    "    将时间序列重构为监督学习数据集.\n",
    "    参数:\n",
    "        data: 观测值序列，类型为列表或Numpy数组。\n",
    "        n_in: 输入的滞后观测值(X)长度。\n",
    "        n_out: 输出观测值(y)的长度。\n",
    "        dropnan: 是否丢弃含有NaN值的行，类型为布尔值。\n",
    "    返回值:\n",
    "        经过重组后的Pandas DataFrame序列.\n",
    "    \"\"\"\n",
    "    n_vars = 1 if type(data) is list else data.shape[1]\n",
    "    df = DataFrame(data)\n",
    "    cols, names = list(), list()\n",
    "    # 输入序列 (t-n, ... t-1)\n",
    "    for i in range(n_in, 0, -1):\n",
    "        cols.append(df.shift(i))\n",
    "        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    # 预测序列 (t, t+1, ... t+n)\n",
    "    for i in range(0, n_out):\n",
    "        cols.append(df.shift(-i))\n",
    "        if i == 0:\n",
    "            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]\n",
    "        else:\n",
    "            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    # 将列名和数据拼接在一起\n",
    "    agg = concat(cols, axis=1)\n",
    "    agg.columns = names\n",
    "    # 丢弃含有NaN值的行\n",
    "    if dropnan:\n",
    "        agg.dropna(inplace=True)\n",
    "    return agg\n",
    "\n",
    "# 根据四元数计算位置\n",
    "def LocationCalculate(x, y, z, w):\n",
    "    X = 2 * x * z + 2 * y * w\n",
    "    Y = 2 * y * z - 2 * x * w\n",
    "    Z = 1 - 2 * x * x - 2 * y * y\n",
    "\n",
    "    a = np.arccos(np.sqrt(X ** 2 + Z ** 2) / np.sqrt(X ** 2 + Y ** 2 + Z ** 2))\n",
    "    if Y > 0:\n",
    "        ver = a / np.pi * 180\n",
    "    else:\n",
    "        ver = -a / np.pi * 180\n",
    "\n",
    "    b = np.arccos(X / np.sqrt(X ** 2 + Z ** 2))\n",
    "    if Z < 0:\n",
    "        hor = b / np.pi * 180\n",
    "    else:\n",
    "        hor = (2. - b / np.pi) * 180\n",
    "\n",
    "    return (90 - ver) / 180, hor / 360\n",
    "\n",
    "\n",
    "# 计算视频每1s内用户观看的位置: 也就是每帧的用户观看位置\n",
    "def userLocal_One(FrameRate, UserFile, TotalSeconds, FH, FW):\n",
    "    \"\"\" \n",
    "    :param FrameRate: FPS\n",
    "    :param UserFile: The filename of file which stores user's viewport location data\n",
    "    :param TotalFrames: 帧总数\n",
    "    :param FH and FW: 帧宽度和帧高度\n",
    "    :return: UserLocationPerFrame: length = TotalSeconds * FrameRate\n",
    "    \"\"\"\n",
    "\n",
    "    \"\"\"\n",
    "        Read user data file and collect all records\n",
    "        Save them in two lists: Userdata and TimeStamp\n",
    "        Userdata is where store the user location (convert to float)\n",
    "        TimeStamp is for syncronization\n",
    "    \"\"\"\n",
    "\n",
    "    Userdata = []\n",
    "    flagTime = 1\n",
    "    TimeStamp = []\n",
    "    with open(UserFile) as csvfile:\n",
    "        csv_reader = csv.reader(csvfile)  # 使用csv.reader读取csvfile中的文件\n",
    "        birth_header = next(csv_reader)  # 读取第一行每一列的标题\n",
    "        for row in csv_reader:  # 将csv 文件中的数据保存到Userdata中\n",
    "            Userdata.append(row[1:])\n",
    "            if flagTime == 1:\n",
    "                TimeStamp.append(row[0])\n",
    "    flagTime = 0\n",
    "    Userdata = [[float(x) for x in row] for row in Userdata]  # 将数据从string形式转换为float\n",
    "    # Userdata = np.array(Userdata)  # 将list数组转化成array数组便于查看数据结构\n",
    "    # print(\"len of Userdata[0]:\", len(Userdata[0]))\n",
    "    strItem = TimeStamp[0].split(':')\n",
    "    PreTime = math.ceil(float(strItem[2]))\n",
    "    CurTime = math.floor(float(strItem[2]))\n",
    "    NumberCount = 0\n",
    "    UserLocationPerFrame = []\n",
    "    all_dataPerFrame = []\n",
    "    j = 0  # j for all items in one user\n",
    "    while NumberCount < TotalSeconds:\n",
    "        NumberCount += 1\n",
    "        UserAll = []\n",
    "        Datain1s = []\n",
    "        '''\n",
    "        通过用户数据中第一列，时间戳信息，获取每一秒内的用户location。该秒内用户数据记录可能大于帧率也可能小于帧率\n",
    "        '''\n",
    "        while PreTime > CurTime:\n",
    "            # TimeStamp[j] 形如 2016-11-17 02:14:34.804\n",
    "            if (j >= len(TimeStamp)):\n",
    "                print('UserFileError...Out of index for TimeStamp. len(UserLocationPerFrame)=', len(UserLocationPerFrame))\n",
    "                exit()\n",
    "            strA = TimeStamp[j].split(':')\n",
    "            CurTime = math.floor(float(strA[2]))\n",
    "            if CurTime == 0 and PreTime == 60:\n",
    "                break\n",
    "            x = Userdata[j][1]\n",
    "            y = Userdata[j][2]\n",
    "            z = Userdata[j][3]\n",
    "            w = Userdata[j][4]\n",
    "            H, W = LocationCalculate(x, y, z, w)\n",
    "            IH = math.floor(H * FH)\n",
    "            IW = math.floor(W * FW)\n",
    "            UserAll.append([IW, IH])    # 应该是计算用户视野范围\n",
    "            Datain1s.append(Userdata[j][1:] + [IW, IH])\n",
    "            # print(\">>>>>>>>>>>>>>>>     \", H,W, \"   <<<<<<<<<<<<<<<<<<<<<<<\")\n",
    "            # print(IW,IH)\n",
    "            j = j + 1\n",
    "        PreTime = CurTime + 1\n",
    "        '''\n",
    "        获得每一秒内用户视角记录后，整理每一帧用户视角位置\n",
    "        '''\n",
    "        LengthInOneSec = len(UserAll)\n",
    "        if LengthInOneSec >= FrameRate:\n",
    "            IntervalIndex = LengthInOneSec / FrameRate\n",
    "            for IU in range(FrameRate):\n",
    "                ModiIndex = int(round(IU * IntervalIndex))\n",
    "                if ModiIndex >= len(UserAll):\n",
    "                    print(\"Large than FrameRate\", ModiIndex, len(UserAll))\n",
    "                UserLocationPerFrame.append(UserAll[ModiIndex])\n",
    "                all_dataPerFrame.append(Datain1s[ModiIndex])\n",
    "        else:\n",
    "            IntervalIndex = LengthInOneSec / FrameRate\n",
    "            for IU in range(FrameRate):\n",
    "                ModiIndex = int(round(IU * IntervalIndex))\n",
    "                if ModiIndex >= len(UserAll):\n",
    "                    print(\"Less than FrameRate\", ModiIndex, len(UserAll))\n",
    "                    ModiIndex = len(UserAll) - 1\n",
    "                UserLocationPerFrame.append(UserAll[ModiIndex])\n",
    "                all_dataPerFrame.append(Datain1s[ModiIndex])\n",
    "    return UserLocationPerFrame, all_dataPerFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Frame width: 1280.0\n",
      "Frame height: 716.0\n",
      "FrameRate: 30\n",
      "TotalFrames: 8797.0\n",
      "TotalSecond (totalframes / framerate): 293\n",
      "len(all_dataPF) and len(all_locationPF): 8790 8790\n"
     ]
    }
   ],
   "source": [
    "# 全局变量\n",
    "VIDEO_PATH = \"../videos/1-3-360 Google Spotlight Stories_ HELP.mp4\"  # 视频地址\n",
    "UserFile = '../vr-dataset/Experiment_1/1/video_2.csv'\n",
    "\n",
    "cap = cv.VideoCapture(VIDEO_PATH)\n",
    "W_Frame = cap.get(3)\n",
    "H_Frame = cap.get(4)\n",
    "print(\"Frame width:\", W_Frame)\n",
    "print(\"Frame height:\", H_Frame)\n",
    "FrameRate = int(round(cap.get(5)))  # 29.9 fps changed to 30\n",
    "TotalFrames = cap.get(7)    # 视频总帧数\n",
    "TotalSeconds = int(round(TotalFrames / FrameRate))  # 视频时长\n",
    "print(\"FrameRate:\", FrameRate)\n",
    "print(\"TotalFrames:\", TotalFrames)\n",
    "print(\"TotalSecond (totalframes / framerate):\", TotalSeconds)\n",
    "cap.release()\n",
    "\n",
    "all_locationPF, all_dataPF = userLocal_One(int(FrameRate), UserFile, TotalSeconds, H_Frame, W_Frame)\n",
    "print(\"len(all_dataPF) and len(all_locationPF):\", len(all_dataPF), len(all_locationPF))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "reframe: \n    var1(t-1)  var2(t-1)  var3(t-1)  var4(t-1)  var5(t-1)  var6(t-1)  \\\n1     -0.010      0.951     -0.011     -0.308     -0.143      1.135   \n2     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n3     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n4     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n5     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n\n   var7(t-1)  var8(t-1)  var8(t+59)  \n1     -0.216      447.0       224.0  \n2     -0.216      447.0       213.0  \n3     -0.216      447.0       198.0  \n4     -0.216      447.0       180.0  \n5     -0.216      447.0       163.0   \n    var1(t-1)  var2(t-1)  var3(t-1)  var4(t-1)  var5(t-1)  var6(t-1)  \\\n1     -0.010      0.951     -0.011     -0.308     -0.143      1.135   \n2     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n3     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n4     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n5     -0.011      0.951     -0.011     -0.308     -0.143      1.135   \n\n   var7(t-1)  var9(t-1)  var9(t+59)  \n1     -0.216      364.0       379.0  \n2     -0.216      364.0       378.0  \n3     -0.216      364.0       376.0  \n4     -0.216      364.0       376.0  \n5     -0.216      364.0       375.0  \nvalues.shape: (8730, 9) (8730, 9)\n"
     ]
    }
   ],
   "source": [
    "dataDF = series_to_supervised(np.array(all_dataPF), 1, 60)\n",
    "colsx = list(range(9, 547)) + [8, 548]\n",
    "colsy = list(range(9, 547)) + [7, 547]\n",
    "dataDFx = dataDF.drop(dataDF.columns[colsx], axis=1)\n",
    "dataDFy = dataDF.drop(dataDF.columns[colsy], axis=1)\n",
    "print(\"reframe: \\n\", dataDFx.head(), '\\n', dataDFy.head())\n",
    "\n",
    "valuesx = dataDFx.values\n",
    "valuesy = dataDFy.values\n",
    "print(\"values.shape:\", valuesx.shape, valuesy.shape)\n",
    "\n",
    "input_size = 8      # 输入特征数\n",
    "hidden_size = 32\n",
    "output_size = 1\n",
    "batch_size = 1      # 输出特征数\n",
    "num_layers = 1"
   ]
  },
  {
   "source": [
    "## LSTM模型"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "myLSTM(\n  (rnn): LSTM(8, 32)\n  (output_layer): Linear(in_features=32, out_features=1, bias=True)\n) myLSTM(\n  (rnn): LSTM(8, 32)\n  (output_layer): Linear(in_features=32, out_features=1, bias=True)\n)\nTrue\n"
     ]
    }
   ],
   "source": [
    "class Model(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, batch_size, num_layers=1):\n",
    "        super(Model, self).__init__()\n",
    "        self.rnn = nn.RNN(\n",
    "            input_size=input_size,\n",
    "            hidden_size=hidden_size,\n",
    "            num_layers=num_layers, )\n",
    "        self.output_layer = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, inputs, h_state):\n",
    "        # x (time_step, batch, input_size)\n",
    "        # h_state (n_layers, batch, hidden_size)\n",
    "        # rnn_out (time_step, batch, hidden_size)\n",
    "        rnn_out, h_state = self.rnn(inputs, h_state)   # h_state是之前的隐层状态\n",
    "        out = []\n",
    "        for time in range(rnn_out.size(0)):\n",
    "            every_time_out = rnn_out[time, :, :]       # 相当于获取每个时间点上的输出，然后过输出层\n",
    "            out.append(self.output_layer(every_time_out))\n",
    "        return torch.stack(out, dim=1).view(-1, output_size), h_state\n",
    "\n",
    "class myLSTM(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, batch_size, num_layers=1):\n",
    "        super(myLSTM, self).__init__()\n",
    "        self.num_layers = num_layers\n",
    "        self.hidden_size = hidden_size\n",
    "        self.rnn = nn.LSTM(\n",
    "            input_size=input_size,\n",
    "            hidden_size=hidden_size,\n",
    "            num_layers=num_layers, )\n",
    "        self.output_layer = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, inputs, hc):\n",
    "        # x (time_step, batch, input_size)\n",
    "        # h_state (n_layers, batch, hidden_size)\n",
    "        # rnn_out (time_step, batch, hidden_size)\n",
    "        rnn_out, hc = self.rnn(inputs, hc)   # h_state是之前的隐层状态\n",
    "        # print(\"rnn_out shape:\", rnn_out.shape)\n",
    "        return self.output_layer(rnn_out.view(-1, hidden_size)), hc    # 直接使用rnn_out，不分开时间点考虑\n",
    "\n",
    "        # out = []\n",
    "        # for time in range(rnn_out.size(0)):\n",
    "        #     every_time_out = rnn_out[time, :, :]       # 相当于获取每个时间点上的输出，然后过输出层\n",
    "        #     out.append(self.output_layer(every_time_out))\n",
    "        # return torch.stack(out, dim=1).view(-1, output_size), hc\n",
    "\n",
    "# net = Model(input_size, hidden_size, batch_size,num_layers)\n",
    "net = myLSTM(input_size, hidden_size, batch_size, num_layers)\n",
    "nety = myLSTM(input_size, hidden_size, batch_size, num_layers)\n",
    "# if torch.cuda.is_available():\n",
    "#     net = net.cuda()\n",
    "#     nety = nety.cuda()\n",
    "\n",
    "print(net, nety)\n",
    "print(torch.cuda.is_available())\n",
    "\n",
    "criterion = torch.nn.MSELoss(reduction='mean')\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=0.01)\n",
    "\n",
    "criteriony = torch.nn.MSELoss(reduction='mean')\n",
    "optimizery = torch.optim.Adam(nety.parameters(), lr=0.01)"
   ]
  },
  {
   "source": [
    "## 训练过程"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 100\n",
    "def train(inputs, targets):\n",
    "    h_state = None\n",
    "    loss = 0\n",
    "    for epoch in range(epochs):\n",
    "        optimizer.zero_grad()\n",
    "        outputs, h_state = net(inputs, h_state)\n",
    "        # 必须要使用detach() https://www.cnblogs.com/catnofishing/p/13287322.html\n",
    "        # h_state = h_state.detach()\n",
    "        h_state = (h_state[0].detach(), h_state[1].detach())\n",
    "        \n",
    "        # 这里的outputs维度是([seqLen * batch_size, output_size])\n",
    "        loss = criterion(outputs, targets) \n",
    "        # print(outputs.shape)\n",
    "        # break\n",
    "        loss.backward() \n",
    "        optimizer.step()\n",
    "        # print(f'Epoch={epoch+1}, Loss={loss.item()}')\n",
    "        \n",
    "        if (loss.item() < 0.00001) :\n",
    "            # print(f'[{outputs[0].data[0] * W_Frame}, {outputs[0].data[1] * H_Frame}], [{targets[0].data[0] * W_Frame}, {targets[0].data[1] * H_Frame}]')\n",
    "            print(f'Epoch={epoch+1}, Loss={loss.item()}')\n",
    "            break\n",
    "    return outputs, loss\n",
    "\n",
    "def trainy(inputs, targets):\n",
    "    h_state = None\n",
    "    loss = 0\n",
    "    for epoch in range(epochs):\n",
    "        optimizery.zero_grad()\n",
    "        outputs, h_state = nety(inputs, h_state)\n",
    "        # 必须要使用detach() https://www.cnblogs.com/catnofishing/p/13287322.html\n",
    "        # h_state = h_state.detach()\n",
    "        h_state = (h_state[0].detach(), h_state[1].detach())\n",
    "        \n",
    "        # 这里的outputs维度是([seqLen * batch_size, output_size])\n",
    "        loss = criteriony(outputs, targets) \n",
    "        # print(outputs.shape)\n",
    "        # break\n",
    "        loss.backward() \n",
    "        optimizery.step()\n",
    "        # print(f'Epoch={epoch+1}, Loss={loss.item()}')\n",
    "        \n",
    "        if (loss.item() < 0.0001) :\n",
    "            # print(f'[{outputs[0].data[0] * W_Frame}, {outputs[0].data[1] * H_Frame}], [{targets[0].data[0] * W_Frame}, {targets[0].data[1] * H_Frame}]')\n",
    "            print(f'Epoch={epoch+1}, Loss={loss.item()}')\n",
    "            break\n",
    "    return outputs, loss"
   ]
  },
  {
   "source": [
    "## 单独训练x"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Epoch=80, Loss=8.577525477448944e-06\n",
      "Epoch=88, Loss=8.298143256979529e-06\n",
      "end for 49 train...\n",
      "len(pre_X) and len(true_X) 392 392\n"
     ]
    }
   ],
   "source": [
    "bufLen = 60\n",
    "SubSampleStep = 8\n",
    "\n",
    "fx = open(r\"C:\\Users\\pengshuai\\Desktop\\8-8x.txt\", \"w+\")\n",
    "pre_X = []\n",
    "true_X = []\n",
    "\n",
    "\n",
    "for baseId in range(1, 50):\n",
    "    train_X = valuesx[(baseId - 1) * bufLen: baseId * bufLen, :-1]\n",
    "    sx = MinMaxScaler()\n",
    "    train_X = sx.fit_transform(train_X)\n",
    "    rows = []\n",
    "    for i in range(len(train_X)):\n",
    "        if i % SubSampleStep != 0:\n",
    "            rows.append(i)\n",
    "    train_X = np.delete(train_X, rows, axis=0)\n",
    "    \n",
    "    train_Y = valuesx[(baseId - 1) * bufLen: baseId * bufLen, -1:]\n",
    "    sy = MinMaxScaler()\n",
    "    train_Y = sy.fit_transform(train_Y)\n",
    "    train_Y = np.delete(train_Y, rows, axis=0)\n",
    "\n",
    "    seq_len = len(train_X)\n",
    "    inputs = torch.Tensor(train_X).view(seq_len, batch_size, input_size)\n",
    "    targets = torch.Tensor(train_Y)\n",
    "\n",
    "    outputs, lossLSTM = train(inputs, targets)\n",
    "\n",
    "    test_X = valuesx[baseId * bufLen : (baseId + 1) * bufLen, :-1]\n",
    "    test_X = sx.transform(test_X)\n",
    "    rows = []\n",
    "    for i in range(len(test_X)):\n",
    "        if i % SubSampleStep != 0:\n",
    "            rows.append(i)\n",
    "    test_X = np.delete(test_X, rows, axis=0)\n",
    "    test_X = torch.Tensor(test_X).view(len(test_X), batch_size, input_size)\n",
    "    \n",
    "    true_Y = valuesx[baseId * bufLen : (baseId + 1) * bufLen, -1:]\n",
    "    ture_Y = sy.transform(true_Y)\n",
    "    true_Y = np.delete(true_Y, rows, axis=0)\n",
    "\n",
    "    pre_Y, _ = net(test_X, None)\n",
    "    pre_Y = sy.inverse_transform(pre_Y.detach().numpy()) \n",
    "    fx.write(f'baseId={baseId} lossLSTM={round(lossLSTM.item(), 4)} train for LSTM ... shape(train_X nad true_X)={train_X.shape, train_Y.shape}\\n')\n",
    "    for i in range(len(test_X)):\n",
    "        fx.write(f'predict=[{int(pre_Y[i].data[0])}], ture={true_Y[i]}\\n')\n",
    "        pre_X.append(int(pre_Y[i].data[0]))\n",
    "        true_X.append(int(true_Y[i]))\n",
    "\n",
    "fx.close()\n",
    "print(f'end for {baseId} train...')\n",
    "print(\"len(pre_X) and len(true_X)\", len(pre_X), len(true_X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "len(pre_X) and len(true_X) 392 392\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17a67ca8550>"
      ]
     },
     "metadata": {},
     "execution_count": 15
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "print(\"len(pre_X) and len(true_X)\", len(pre_X), len(true_X))\n",
    "n = len(pre_X)\n",
    "\n",
    "num_X = list(range(0, n))\n",
    "\n",
    "plt.plot(num_X, pre_X, 'r-', label='pre-x')\n",
    "plt.plot(num_X, true_X, 'b-', label='true-x')\n",
    "plt.savefig('C:/Users/pengshuai/Desktop/x.png')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17a67d3abe0>"
      ]
     },
     "metadata": {},
     "execution_count": 16
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "source": [
    "step = 8\n",
    "\n",
    "pre = pre_X[::step]\n",
    "true = true_X[::step]\n",
    "num = list(range(0, n, step))\n",
    "\n",
    "plt.plot(num, pre, 'r-', label='pre-x')\n",
    "plt.plot(num, true, 'b-', label='true-x')\n",
    "plt.savefig('C:/Users/pengshuai/Desktop/x-step=8.png')\n",
    "plt.legend()"
   ]
  },
  {
   "source": [
    "## 单独训练y"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Epoch=77, Loss=9.596676682122052e-05\n",
      "Epoch=97, Loss=8.042038098210469e-05\n",
      "Epoch=69, Loss=9.614608279662207e-05\n",
      "Epoch=69, Loss=9.544357453705743e-05\n",
      "Epoch=97, Loss=9.812482312554494e-05\n",
      "Epoch=100, Loss=9.688563295640051e-05\n",
      "Epoch=95, Loss=9.770353062776849e-05\n",
      "Epoch=99, Loss=9.883005986921489e-05\n",
      "Epoch=61, Loss=6.406740430975333e-05\n",
      "Epoch=71, Loss=7.200780237326398e-05\n",
      "Epoch=85, Loss=9.4100039859768e-05\n",
      "Epoch=88, Loss=8.391583105549216e-05\n",
      "Epoch=79, Loss=9.705965203465894e-05\n",
      "Epoch=82, Loss=9.966507059289142e-05\n",
      "Epoch=71, Loss=9.276550554204732e-05\n",
      "Epoch=73, Loss=9.663270611781627e-05\n",
      "end for 49 train...\n"
     ]
    }
   ],
   "source": [
    "bufLen = 60\n",
    "SubSampleStep = 8\n",
    "\n",
    "fy = open(\"C:/Users/pengshuai/Desktop/8-8y.txt\", \"w\")\n",
    "predict_Y = []\n",
    "actual_Y = []\n",
    "\n",
    "\n",
    "for baseId in range(1, 50):\n",
    "    # 准备训练的y\n",
    "    train_X = valuesy[(baseId - 1) * bufLen: baseId * bufLen, :-1]\n",
    "    sx = MinMaxScaler()\n",
    "    train_X = sx.fit_transform(train_X)\n",
    "    rows = []\n",
    "    for i in range(len(train_X)):\n",
    "        if i % SubSampleStep != 0:\n",
    "            rows.append(i)\n",
    "    train_X = np.delete(train_X, rows, axis=0)\n",
    "    \n",
    "    # 准备真实的y，和预测的y做loss\n",
    "    train_Y = valuesy[(baseId - 1) * bufLen: baseId * bufLen, -1:]\n",
    "    sy = MinMaxScaler()\n",
    "    train_Y = sy.fit_transform(train_Y)\n",
    "    train_Y = np.delete(train_Y, rows, axis=0)\n",
    "\n",
    "    seq_len = len(train_X)\n",
    "    inputs = torch.Tensor(train_X).view(seq_len, batch_size, input_size)\n",
    "    targets = torch.Tensor(train_Y)\n",
    "\n",
    "    outputs, lossLSTM = trainy(inputs, targets)\n",
    "\n",
    "    test_X = valuesy[baseId * bufLen : (baseId + 1) * bufLen, :-1]\n",
    "    test_X = sx.transform(test_X)\n",
    "    rows = []\n",
    "    for i in range(len(test_X)):\n",
    "        if i % SubSampleStep != 0:\n",
    "            rows.append(i)\n",
    "    test_X = np.delete(test_X, rows, axis=0)\n",
    "    test_X = torch.Tensor(test_X).view(len(test_X), batch_size, input_size)\n",
    "    \n",
    "    true_Y = valuesy[baseId * bufLen : (baseId + 1) * bufLen, -1:]\n",
    "    ture_Y = sy.transform(true_Y)\n",
    "    true_Y = np.delete(true_Y, rows, axis=0)\n",
    "\n",
    "    pre_Y, _ = nety(test_X, None)\n",
    "    pre_Y = sy.inverse_transform(pre_Y.detach().numpy())\n",
    "    fy.write(f'baseId={baseId} lossLSTM={round(lossLSTM.item(), 4)} train for LSTM ... shape(train_Y nad true_Y)={train_X.shape, train_Y.shape}\\n')\n",
    "    for i in range(len(test_X)):\n",
    "        fy.write(f'predict={int(pre_Y[i].data[0])}, true={true_Y[i]}\\n')\n",
    "        predict_Y.append(int(pre_Y[i].data[0]))\n",
    "        actual_Y.append(int(true_Y[i]))\n",
    "   \n",
    "fy.close()\n",
    "print(f'end for {baseId} train...')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "len(predict_Y) and len(actual_Y) 392 392\n"
     ]
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17a67dc5fd0>"
      ]
     },
     "metadata": {},
     "execution_count": 17
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "source": [
    "n = len(actual_Y)\n",
    "print(\"len(predict_Y) and len(actual_Y)\", len(predict_Y), len(actual_Y))\n",
    "num_Y = list(range(0, n))\n",
    "\n",
    "plt.plot(num_Y, predict_Y, 'r-', label='pre-y')\n",
    "plt.plot(num_Y, actual_Y, 'b-', label='true-y')\n",
    "plt.savefig('C:/Users/pengshuai/Desktop/y.png')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x17a67e434e0>"
      ]
     },
     "metadata": {},
     "execution_count": 19
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     }
    }
   ],
   "source": [
    "step = 8\n",
    "\n",
    "predict = predict_Y[::step]\n",
    "actual = actual_Y[::step]\n",
    "num = list(range(0, n, step))\n",
    "\n",
    "plt.plot(num, predict, 'r-', label='pre-y')\n",
    "plt.plot(num, actual, 'b-', label='true-y')\n",
    "plt.savefig('C:/Users/pengshuai/Desktop/y-step=8.png')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3613jvsc74a57bd014936350beb1dc9c932e03f8f193977d8de370b45561d18d0e0bc6a3c20e44ae",
   "display_name": "Python 3.6.13 64-bit ('pytorch': conda)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.13-final"
  },
  "metadata": {
   "interpreter": {
    "hash": "14936350beb1dc9c932e03f8f193977d8de370b45561d18d0e0bc6a3c20e44ae"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}